IRIX Base Documentation 1998 November/IRIX 6.5.2 Base Documentation November 1998.img/usr/share/catman/u_man/cat1/jot.z/jot

Text File | 1998-10-30 | 54KB | 1,190 lines

JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



NNNNAAAAMMMMEEEE
     jot, jotxgizmo - mouse-based text editor

SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
     jjjjooootttt [----ffffvvvvMMMMxxxx] [----pppp n,n,n,n] [----llll n | ++++n] file ...

DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
     _J_o_t is a display-oriented cut-and-paste style ASCII text editor tuned to
     run on Silicon Graphics machines.  _J_o_t is written using pure Graphics
     Library code, and hence will not work on a generic X terminal, and it
     ignores the X resources.  _J_o_t (which was originally called "zip"), is
     tuned to run well on large files, and can edit arbitrary binary files.

   IIIInnnnvvvvooooccccaaaattttiiiioooonnnn OOOOppppttttiiiioooonnnnssss
     ----ffff        Run _j_o_t in the foreground.  This is often required if you wish
               to use _j_o_t as your mail or news editor.

     ----vvvv        In view-only mode, _j_o_t will not allow you to modify the file
               you are viewing.

     ----MMMM        Mmap the file.  This can nearly double the start-up speed for
               large files, but may not work reliably on remote-mounted files.

     ----xxxx        Backup override -- overrides saving of backup and checkpoint
               files.

     ----llll _n

     ++++_n        Start _j_o_t at line _n of the file. If this option is specified as
               ++++_n, this flag must come after all the other options and before
               the first file name.

     ----pppp _n,_n,_n,_n
               Place the _j_o_t window at xmin,xmax,ymin,ymax.  To specify the
               size and not the position, use negative values for xmin and
               ymin to indicate the dimensions -- in this case, the xmax and
               ymax values are ignored.  For example, -p -400,0,-600,0 makes a
               window 400 pixels wide and 600 high.

     The file argument indicates a list of files to be edited.  If more than
     one file is named, _j_o_t edits the first, and adds the others to the reopen
     list.  If no file is specified, and the jotcruft option is set in the
     .jotrc file, _j_o_t will come up with the same file and reopen list it had
     when you last quit _j_o_t in that directory.  See the section on UUUUSSSSEEEERRRR
     PPPPRRRREEEEFFFFEEEERRRREEEENNNNCCCCEEEESSSS, below.

UUUUSSSSEEEERRRR PPPPRRRREEEEFFFFEEEERRRREEEENNNNCCCCEEEESSSS
     The ASCII file .jotrc in your home directory contains user preferences.
     The parser is pretty idiotic, so errors in this file can cause problems.
     Each option must appear on its own line.  A '#' character at the
     beginning of a line will comment it out.





                                                                        PPPPaaaaggggeeee 1111






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



   UUUUsssseeeerrrr PPPPrrrreeeeffffeeeerrrreeeennnncccceeee OOOOppppttttiiiioooonnnnssss
     autoaddnewline      This will cause _j_o_t to add a newline to the end of
                         each file if one is not present.  Even without this
                         option, you will be warned about a missing final
                         newline when you write a file.

     autoindent          When you type <Enter> or _j_o_t automatically breaks a
                         line in word-wrap mode, _j_o_t will add enough white
                         space at the beginning of the line to match the
                         indentation of the previous line.

     autosavecount #     Every # keystrokes, _j_o_t will automatically make a
                         checkpoint file with a ".sav" extension.

     backups             When you start _j_o_t, or visit a new file, a backup
                         version of your file is written with a ".bak"
                         extension.

     colors # # # #      Sets the GL color index values of the background,
                         text, cursor, and selection.  _J_o_t does not change the
                         color map; it just uses the mapped colors it finds.
                         See markcolor.

     commentcolumn #     This sets the column number used by the insert-
                         comment command.

     cyclesearch         This starts _j_o_t in cycle search mode in which search
                         commands automatically continue through all the files
                         in the reopen list.

     dblclktime #        Sets the time in 1/100 seconds for the double click
                         time for _j_o_t.  The default is 20.

     electriccmode       When a file with extension ".c", ".h", ".C", ".l",
                         ".y", ".v", ".dv", ".iv", ".C++", or ".c++" is
                         visited, _j_o_t is put into electric-c mode, and some
                         commands behave slightly differently.

     expertmenus         More extensive pull-down menus appear.

     fontpath path       path is an absolute path name for a font to be used
                         instead of the default for text.  The font must be in
                         .pcf format (or .pcf.Z format), and must be fixed-
                         pitch.

     hardtabsize #       sets the tab size for physical tab characters.  (See
                         the description of tabs under GGGGEEEENNNNEEEERRRRAAAALLLL FFFFEEEEAAAATTTTUUUURRRREEEESSSS.)

     incrsearch          Puts _j_o_t in incremental search mode.  When a new
                         search is begun with <A-F>, as each character is
                         typed, the search continues to the next place in the
                         file that the string so far typed appears. For



                                                                        PPPPaaaaggggeeee 2222






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



                         example, if the cursor were at the beginning of this
                         paragraph, and you searched for "thex", the "t" would
                         put you at the "t" in "Put" in line 1, the "h" in
                         "with" in line 2, "e" to "the" in line 3, and "x" to
                         the "thex" in line 6.  Type <Esc> or any other non-
                         character command to get out of the search mode.

     jotcruft            Causes _j_o_t to save a file with the name ".jotcruft"
                         in each directory where you exit from _j_o_t.  The
                         .jotcruft file contains the currently open file and
                         the files in the reopen list, together with the
                         selections and marks defined in those files.  If you
                         invoke _j_o_t without a file name, the state in the
                         .jotcruft file will be restored.  If _j_o_t is invoked
                         with a file name, the .jotcruft information is
                         ignored.

     leftscroll          Puts the scroll bar on the left.  Motif requires a
                         right-hand scroll bar, which doesn't make much sense
                         for text editors.

     linenumbers         Causes _j_o_t to display line numbers by default.

     locale file         _J_o_t reads the file named file to get
                         internationalization information.  The file must
                         contain the correct messages in the correct order.

     mapkey key meta cmd Remap a command to a different key.  The first entry
                         is the key name, as specified in the file
                         /usr/include/gl.h, like AKEY, ZEROKEY, et cetera.
                         The meta entry is one of NONE, SHIFT, CTRLSHIFT, ALT,
                         ALTSHIFT, ALTCTRL, ALTCTRLSHIFT, and the third is the
                         command name.  A complete list of command names
                         appears under COMMAND NAMES, below.  For example:

     mapkey CKEY CTRLSHIFT ENDFILECMD

     will cause _j_o_t to move the cursor to the end of the file when you hold
     down the control and shift keys and type the 'C' key.

     margin #            Sets the right margin which is used in word wrap mode
                         and for paragraph reformatting.  It is in column 72
                         by default.

     markcolor #         The color index for the marks and line numbers.  See
                         colors.

     nobrowsegizmo       Causes _j_o_t to use its internal high-speed file name
                         chooser instead of the browse gizmo.  If the
                         browsegizmo is not installed, _j_o_t will always use its
                         own file chooser.




                                                                        PPPPaaaaggggeeee 3333






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     nocase              Causes searches to be case-independent by default.

     oldstyle            Runs _j_o_t in the old default zip modes -- the old fast
                         font is used, the scroll bar is on the left, the
                         right mouse button pans, and expert menus are
                         enabled.

     oldaccelerators     Runs _j_o_t with the original Alt key accelerators.
                         Accelerators are also called "speed-keys" or
                         "shortcuts" position # # # # The numbers represent
                         the same values as in the "-p" command line option to
                         _j_o_t.

     rightmousepan       Pressing the right mouse button pans the text, rather
                         than invoking a popup menu.

     tabsize #           Sets the tab column size.  See "tabs" in the GGGGEEEENNNNEEEERRRRAAAALLLL
                         FFFFEEEEAAAATTTTUUUURRRREEEESSSS section.

     undobuffersize #    Sets the size of the undo buffer.  By default it is
                         2000.  Commands of differing complexity use different
                         numbers of undo buffer entries.  Most commands use
                         only a few entries, but a global search/replace can
                         use a large number of entries.  There is no penalty
                         (except for process size) for having a larger undo
                         buffer.  The undo buffer is a circular queue, so
                         normally a few hundred operations can be undone.

     wordwrap            Enables word wrapping when you type with your cursor
                         at the end of a line past the right margin.  Adding
                         text in the middle of the line will not word-wrap.
                         Use the reformat command (<A-R>) to reformat such
                         paragraphs.

WWWWIIIINNNNDDDDOOOOWWWW HHHHEEEEAAAADDDDEEEERRRR
     If your window manager has window headers, _j_o_t displays some interesting
     information in its header:

     * (asterisk)        indicates that the file is modified.

     [Macro F* Open]     Macro F1, F2, ..., or F12 is being created.

     [Incr search ...]   _J_o_t is doing an incremental search.

     [View Only]         The file is open in view-only mode.

CCCCOOOOMMMMMMMMAAAANNNNDDDD SSSSUUUUMMMMMMMMAAAARRRRYYYY
     In the descriptions, 'A' stands for the left Alt key, 'C' for a Control
     key, 'S' for a shift key (where emphasis is needed), and the '<' and '>'
     symbols bound the command.  Note that although there is a right Alt key,
     it is reserved as a "compose" key for internationalization.  For example,
     the command "<C-a>" means to hold down the control key while you type a



                                                                        PPPPaaaaggggeeee 4444






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     lower-case 'a'; "<C-A-P>" means to hold down both the control and alt
     keys while you type an upper-case 'P'.  There are two sets of keyboard
     commands.  The first table lists the default command accelerators.  The
     second set of accelerators is used when "oldaccelerators" or "oldstyle"
     at set in the $HOME/.jotrc file.  These are the default accelerators from
     previous versions of jot.

     Commands followed by an asterisk are explained further in the GGGGEEEENNNNEEEERRRRAAAALLLL
     FFFFEEEEAAAATTTTUUUURRRREEEESSSS section.

DDDDeeeeffffaaaauuuulllltttt CCCCoooommmmmmmmaaaannnndddd AAAAcccccccceeeelllleeeerrrraaaattttoooorrrrssss
   FFFFiiiilllleeee CCCCoooonnnnttttrrrroooollll::::
     <C-n>                 Visit new file
     <C-o>                 Open file
     <C-O>                 Reopen file
     <C-A-o>               Cycle reopen file
     <C-p>                 Print file
     <C-s>                 Save file
     <C-Q>                 Save file and exit (Rambo style)
     <C-q>                 Exit

   MMMMooooddddeeee CCCCoooonnnnttttrrrroooollll::::
     <A-w>                 Toggle word-wrap mode
     <A-Y>                 Toggle auto-indent mode
     <C-A-W>               Toggle electric-c mode
     <A-y>                 Toggle search case
     <C-A-l>               Toggle line number display
     <A-.>                 Show current position

   TTTTeeeexxxxtttt SSSSeeeelllleeeeccccttttiiiioooonnnn::::
     <leftmouse>           Select characters
     <dblclk-leftmouse>    Select words

     If the shift key is held down, the above commands
     extend the selection as above.

     <C-leftmouse>         Select lines
     <C-dblclk-leftmouse>  Select paragraphs
     <A-l>                 Select line
     <A-p>                 Select paragraph
     <C-/>                 Select all
     <A-[>, <A-]>          (Extend) select to matching brackets
     <C-A-J>               Extend selection to line
     <A-e>                 Extend select with search
     <A-E>                 Repeat extend select with search

   CCCCuuuurrrrssssoooorrrr MMMMoooovvvveeeemmmmeeeennnntttt ((((cccchhhhaaaannnnggggeeee sssseeeelllleeeeccccttttiiiioooonnnn))))
     <rightarrow>, <C-f>   Move right character
     <leftarrow>, <C-b>    Move left character
     <uparrow>, <C-p>      Move up character
     <downarrow>, <C-n>    Move down character
     <C-rightarrow>        Move right word



                                                                        PPPPaaaaggggeeee 5555






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     <C-leftarrow>         Move left word
     <C-uparrow>           Move up paragraph
     <C-downarrow>         Move down paragraph
     <A-rightarrow>,<C-e>  Move to end of line
     <A-leftarrow>,<C-a>   Move to start of line
     <A-uparrow>,<C-Home>  Move to beginning of file
     <A-downarrow>,<C-End> Move to end of file

     With the shift key down, the above commands extend the
     selection as above.

     <C-T>                 Jump to tag (*)
     <C-L>, <A-#><C-L>     Jump to line number
     <C-A-j>, <A-#><C-A-j> Jump to column
     <A-W>                 Split window

   CCCChhhhaaaannnnggggeeee VVVViiiieeeewwww ((((ddddoooo nnnnooootttt cccchhhhaaaannnnggggeeee sssseeeelllleeeeccccttttiiiioooonnnn))))
     <leftmouse>           Scroll if cursor is in scroll bar
     <C-A-rightmouse>      Pan text
     <End>                 End of line
     <Home>                Beginning of line
     <A-End>               View end of selection
     <A-Home>              View start of selection
     <PageUp>              Up a page
     <C-PageUp>            Up half a page
     <PageDown>            Down a page
     <C-PageDown>          Down half a page

   CCCCuuuutttt aaaannnndddd PPPPaaaasssstttteeee ((((****))))
     <C-x>                 Cut
     <C-A-x>               X-cut
     <C-c>                 Copy
     <C-v>                 Paste
     <C-A-v>,<middlemouse> X-paste
     <C-rightmouse>        Copy + Paste
     <S-rightmouse>        Cut + Paste

   SSSSeeeeaaaarrrrcccchhhh////RRRReeeeppppllllaaaacccceeee
     <C-F>                 Forward search
     <C-f>                 Repeat previous forward search (*)
     <C-B>                 Backward search
     <C-b>                 Repeat previous backward search
     <C-r>                 Replace dialog
     <C-A-F>               Regular expression forward search
     <C-A-f>               Repeat regular expression search
     <C-A-r>               Regular expression replace
     <A-g>                 Paste + repeat search
     <C-A-g>               Paste + repeat regular expression search
     <C-A-w>               Keyboard replace
     <C-R>                 Bounded replace dialog
     <C-A-R>               Bounded replace regular expression




                                                                        PPPPaaaaggggeeee 6666






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



   GGGGeeeennnneeeerrrraaaallll EEEEddddiiiittttiiiinnnngggg
     <C-z>                 Undo last operation (*)
     <C-Z>                 Redo last undo
     <C-k>                 Kill to end of line (*)
     <C-u>                 Kill to beginning of line
     <C-c>                 Center selected lines
     <Insert>              Repeat last typein
     <A-U>                 Selection to uppercase
     <A-L>                 Selection to lowercase
     <A-C>                 Selection to first letter uppercase
     <C-d>                 Kill next character
     <A-d>                 Kill next word
     <Backspace>           Kill previous character
     <A-Backspace>         Kill previous word
     <Delete>              Kill previous character, hacking tabs (*)
     <S-Tab>               Backward tab
     <C-Tab>               Insert raw tab character
     <C-,>                 Insert raw comma in electric-c mode
     <C-Enter>             Insert raw newline character
     <C-R>, <A-#><C-R>     Reformat paragraphs (to # columns) (*)
     <C-i>, <A-#><C-i>     Indent 4 (or #) characters
     <C-I>, <A-#><C-I>     Outdent 4 (or #) characters
     <A-Enter>,                                  Newline plus indent
     <A-%>                 Insert C comment
     <A-#><Esc>            Insert ASCII character (*)
     <C-Esc>char           Insert ASCII character (*)
     <C-Esc><A-char>       Insert ASCII character with high bit on (*)

   MMMMaaaaccccrrrroooossss ((((****))))
     <C-F#>                Define/End Definition of macro F#
     <F#>                  Invoke macro F#
     <C-A-M>               Save macro definitions in ~/.jotmacs

   FFFFiiiilllltttteeeerrrrssss ((((****))))
     <C-G>                 Filter selected text
     <C-A-p>               Filter from cutbuffer
     <C-A-P>               Filter to shell

   MMMMaaaarrrrkkkkssss ((((****))))
     <C-m>, <A-#><C-m>     Insert mark (#)
     <C-j>, <A-#><C-j>     Jump to mark
     <C-M>, <A-#><C-M>     Delete mark (#)
     <A-k>                 Textpointers to marks
     <A-K>                 Marks to textpointers
     <C-A-k>               Swap marks and textpointers

OOOOlllldddd CCCCoooommmmmmmmaaaannnndddd AAAAcccccccceeeelllleeeerrrraaaattttoooorrrrssss
   FFFFiiiilllleeee CCCCoooonnnnttttrrrroooollll::::
     <A-n>                 Visit new file
     <A-o>                 Open file
     <A-O>                 Reopen file
     <C-A-o>               Cycle reopen file



                                                                        PPPPaaaaggggeeee 7777






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     <A-s>                 Save file
     <A-S>                 Save file (as ...)
     <C-I>                 Insert file
     <C-A-s>               Save file and quit (Rambo style)

   MMMMooooddddeeee CCCCoooonnnnttttrrrroooollll::::
     <A-w>                 Toggle word-wrap mode
     <A-Y>                 Toggle auto-indent mode
     <C-A-W>               Toggle electric-c mode
     <A-y>                 Toggle search case
     <C-A-l>               Toggle line number display
     <A-.>                 Show current position

   TTTTeeeexxxxtttt SSSSeeeelllleeeeccccttttiiiioooonnnn::::
     <leftmouse>           Select characters
     <dblclk-leftmouse>    Select words

     If the shift key is held down, the above commands
     extend the selection as above.

     <C-leftmouse>         Select lines
     <C-dblclk-leftmouse>  Select paragraphs
     <A-l>                 Select line
     <A-p>                 Select paragraph
     <A-a>                 Select all
     <A-[>, <A-]>          (Extend) select to matching brackets
     <C-A-J>               Extend selection to line
     <A-e>                 Extend select with search
     <A-E>                 Repeat extend select with search

   CCCCuuuurrrrssssoooorrrr MMMMoooovvvveeeemmmmeeeennnntttt ((((cccchhhhaaaannnnggggeeee sssseeeelllleeeeccccttttiiiioooonnnn))))
     <rightarrow>, <C-f>   Move right character
     <leftarrow>, <C-b>    Move left character
     <uparrow>, <C-p>      Move up character
     <downarrow>, <C-n>    Move down character
     <C-rightarrow>        Move right word
     <C-leftarrow>         Move left word
     <C-uparrow>           Move up paragraph
     <C-downarrow>         Move down paragraph
     <A-rightarrow>, <C-e> Move to end of line
     <A-leftarrow>, <C-a>  Move to start of line
     <A-uparrow>           Move to beginning of file
     <A-downarrow>         Move to end of file

     With the shift key down, the above commands extend the
     selection as above.

     <A-J>                 Jump to tag (*)
     <A-j>, <A-#><A-j>     Jump to line number
     <C-A-j>, <A-#><C-A-j> Jump to column
     <A-W>                 Split window




                                                                        PPPPaaaaggggeeee 8888






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



   CCCChhhhaaaannnnggggeeee VVVViiiieeeewwww ((((ddddoooo nnnnooootttt cccchhhhaaaannnnggggeeee sssseeeelllleeeeccccttttiiiioooonnnn))))
     <leftmouse>           Scroll if cursor is in scroll bar
     <C-A-rightmouse>      Pan text
     <End>                 View end of file
     <Home>                View beginning of file
     <A-End>               View end of selection
     <A-Home>              View start of selection
     <PageUp>              Up a page
     <C-PageUp>            Up half a page
     <PageDown>            Down a page
     <C-PageDown>          Down half a page

   CCCCuuuutttt aaaannnndddd PPPPaaaasssstttteeee ((((****))))
     <A-x>                 Cut
     <C-A-x>               X-cut
     <A-c>                 Copy
     <C-v>                 Paste
     <C-A-v>,<middlemouse> X-paste
     <A-z>                 Append to selection
     <C-S-.>               Show cut buffer
     <C-rightmouse>        Copy + Paste
     <S-rightmouse>        Cut + Paste

   SSSSeeeeaaaarrrrcccchhhh////RRRReeeeppppllllaaaacccceeee
     <A-F>                 Forward search
     <A-f>                 Repeat previous forward search (*)
     <A-B>                 Backward search
     <A-b>                 Repeat previous backward search
     <C-r>                 Replace dialog
     <C-A-F>               Regular expression forward search
     <C-A-f>               Repeat regular expression search
     <C-A-r>               Regular expression replace
     <A-g>                 Paste + repeat search
     <C-A-g>               Paste + repeat regular expression search
     <C-A-w>               Keyboard replace
     <C-R>                 Bounded replace dialog
     <C-A-R>               Bounded replace regular expression

   GGGGeeeennnneeeerrrraaaallll EEEEddddiiiittttiiiinnnngggg
     <A-u>                 Undo last operation (*)
     <A-r>                 Redo last undo
     <C-k>                 Kill to end of line (*)
     <C-u>                 Kill to beginning of line
     <C-c>                 Center selected lines
     <Insert>              Repeat last typein
     <A-U>                 Selection to uppercase
     <A-L>                 Selection to lowercase
     <A-C>                 Selection to first letter uppercase
     <C-o>                 Open next line
     <C-O>                 Open previous line
     <C-t>                 Transpose characters (*)
     <C-d>                 Kill next character



                                                                        PPPPaaaaggggeeee 9999






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     <A-d>                 Kill next word
     <Backspace>           Kill previous character
     <A-Backspace>         Kill previous word
     <Delete>              Kill previous character, hacking tabs (*)
     <S-Tab>               Backward tab
     <C-Tab>               Insert raw tab character
     <C-,>                 Insert raw comma in electric-c mode
     <C-Enter>             Insert raw newline character
     <A-R>, <A-#><A-R>     Reformat paragraphs (to # columns) (*)
     <A-i>, <A-#><A-i>     Indent 4 (or #) characters
     <A-I>, <A-#><A-I>     Outdent 4 (or #) characters
     <A-Enter>, <C-j>      Newline plus indent
     <A-%>                 Insert C comment
     <A-#><Esc>            Insert ASCII character (*)
     <C-v>char             Insert ASCII character (*)
     <C-v><A-char>         Insert ASCII character with high bit on (*)

   MMMMaaaaccccrrrroooossss ((((****))))
     <C-F#>                Define/End Definition of macro F#
     <F#>                  Invoke macro F#
     <C-A-M>               Save macro definitions in ~/.jotmacs

   FFFFiiiilllltttteeeerrrrssss ((((****))))
     <A-P>                 Filter selected text
     <C-A-p>               Filter from cutbuffer
     <C-A-P>               Filter to shell

   MMMMaaaarrrrkkkkssss ((((****))))
     <A-M>, <A-#><A-M>     Insert mark (#)
     <A-m>, <A-#><A-m>     Jump to mark
     <C-A-m>, <A-#><C-A-m> Delete mark (#)
     <A-k>                 Textpointers to marks
     <A-K>                 Marks to textpointers
     <C-A-k>               Swap marks and textpointers

GGGGEEEENNNNEEEERRRRAAAALLLL FFFFEEEEAAAATTTTUUUURRRREEEESSSS
   TTTTaaaabbbbssss
     By default, literal tab characters in a file advance to the next column
     that is a multiple of 8.  If _j_o_t's tab size is something other than 8,
     then pressing the tab key advances to a column that is a multiple of that
     tab size, but it does so by inserting the appropriate combination of tab
     characters and spaces.  In addition, it will clean up spaces before the
     cursor when the tab key is pressed.

     For example, if the tab size is 5, and the cursor is at the beginning of
     a line, the first tab key press will insert 5 spaces. The second press
     will delete those 5, add a raw tab, and then 2 more spaces to advance to
     column 10.  The next tab inserts 5 more spaces, and so on.  The tab size
     can be anything; if it is 17, for example, the first tab from the left
     margin will add two tab characters and 1 space character.





                                                                       PPPPaaaaggggeeee 11110000






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     If you set the hard tab size this will make physical tabs advance by a
     different number of columns.  Usually it is not a good idea to do this
     since so many UNIX utilities depend on a tab size of 8.

     The <Backspace> key deletes the character before the cursor, so if the
     tab size is 4 and you type tab twice from the left margin, there will be
     a single tab behind the cursor.  A backspace at that point eliminates the
     tab character and will put the cursor at the beginning of the line.  The
     <Delete> key is exactly like the backspace key unless there is a tab
     character before it.  If so, the tab is first converted to the
     appropriate number of spaces, and then the final space character is
     deleted.  <Delete> thus moves backward one column at a time, no matter
     whether it is passing tabs or any other character.

   TTTThhhheeee CCCCoooommmmmmmmaaaannnndddd MMMMuuuullllttttiiiipppplllliiiieeeerrrr
     If the <Alt> key is held down while a decimal number is typed, that
     number becomes the command multiplier.  It can have multiple digits.  For
     example, to get a command multiplier of 25, type <A-2><A-5>.

     Normally, the command multiplier is the number of times the next command
     is to be repeated.  <A-1><A-7>a will insert 17 'a's into the file. <A-
     9><A-n> will move the cursor down by 9 lines.

     A few commands interpret the command multiplier differently.  The indent
     and outdent commands interpret the multiplier as the number of columns to
     indent or outdent (the default is 4).  The reformat command interprets it
     as a margin for reformatting.  The jump to line and jump to column
     commands interpret it as the line or column to jump to.  For example,
     <A1><A-2><A-7><A-j> jumps to line 127.

     A command multiplier in the jump to mark, delete mark and set mark
     commands is interpreted as the mark number.

     The command multiplier is also used to insert non-standard characters
     into the file.  See "Typing Weird Characters", below.

   TTTTyyyyppppiiiinnnngggg WWWWeeeeiiiirrrrdddd CCCChhhhaaaarrrraaaacccctttteeeerrrrssss
     There are 2 ways to insert control characters and characters outside the
     ASCII character set into the file.  If a command multiplier is followed
     by an <Esc>, the number is interpreted as the ASCII code and that number
     is inserted.  For example, to insert a 'control-A' (ASCII 1) into your
     file, type: <A-1><Esc>.  Unfortunately, you have to specify the character
     in decimal.

     The other way is to use the <C-Esc> literal escape mechanism.  To insert
     an ASCII 'control-a', type: <C-Esc><C-a>.  If you want the high order bit
     of your character turned on, hold the <Alt> key down while you type the
     next character.  So if you want ASCII 129 (which is the same as
     'control-a' with the high order bit on), type: <C-v><C-A-a>.






                                                                       PPPPaaaaggggeeee 11111111






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     This method can be used to insert unusual characters in search and/or
     replace strings.  _J_o_t cannot, however, search for or replace the newline
     character.

     Non-standard characters are displayed in _j_o_t as 3-character sequences.
     The first character looks like an 'x' with a box around it, (unless
     you've chosen a non-default font, in which case it's an 'X'), followed by
     2 hexadecimal characters.  An ASCII 'control-a' looks something like
     this: "X01".

   EEEElllleeeeccccttttrrrriiiicccc----cccc MMMMooooddddeeee
     In this mode, certain parenthesis-matching operations are performed, tabs
     are set to 4, and auto-indent is enabled.  Some automatic spacing and
     indentation is also performed.  It is quite conservative, and it is not
     customizable.

   TTTThhhheeee RRRReeeeooooppppeeeennnn LLLLiiiisssstttt
     In a _j_o_t session, each time a file is visited, it is added to the reopen
     list.  When a new file is opened, the previous file's position in the
     window, selection, and marks are all saved in the reopen list so that
     revisiting a file puts you back in the same place.  A roll-over menu
     (with long menus enabled) allows easy access to the previously visited
     files.

     If you simply click on the reopen menu entry without rolling over, you'll
     visit the previous file, making it very easy to flip-flop between 2
     files.

   FFFFiiiilllleeee NNNNaaaammmmeeee TTTTyyyyppppeeeeiiiinnnn
     When using the simple _j_o_t file browser, often it has a guess at the file
     name which is presented.  Typing <Enter> selects that name, but typing
     any character erases the entire guess and allows typein from scratch.  To
     modify a guessed name, click the cursor in the typein field, and then
     begin typing.  The paste command works in the typein field as well.

     While typing, <Esc> attempts file name completion.  Typing <uparrow> and
     <downarrow> go though possibilities.  Typing <rightarrow> goes down a
     directory, and <leftarrow>, up a directory.

   MMMMaaaaccccrrrroooossss
     Any sequence of keystrokes, including command multipliers, can be saved
     in macro definitions.  Up to 12 macros invoked by the keys F1, F2, ...,
     F12 can be saved, and the macros can be nested.

     To define a macro, say F3, type <C-F3>, then type the commands you want
     (_j_o_t will perform the commands as you do them), and end the macro
     definition with another <C-F3>.  For example, to make a macro that adds a
     semicolon to the beginning and end of a line and then advances to the
     next line, type:  "<C-F5><C-a>;<C-e>;<C-n><C-F5>". Then to perform this
     operation on the next 150 lines of the file, type: "<A-1><A-5><A-0>F5",
     using the command multiplier.




                                                                       PPPPaaaaggggeeee 11112222






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     All the current macros can be saved in the file ~/.jotmacs using the save
     macros command.

   SSSSccccrrrroooollllllll BBBBaaaarrrr
     In addition to the usual things a scroll bar does, the highlighted
     portion of _j_o_t's scroll bar indicates roughly the size and position of
     the current selection within the file.  In addition, if any marks are
     set, the corresponding numbers are shown in the scroll bar.  The size of
     the thumb is proportional to the size of the viewed window in comparison
     to the size of the whole file, unless the file is huge, in which case the
     thumb is some minimal size.  There's a hole in the thumb to see the
     selection and marks through it.

   SSSSeeeeaaaarrrrcccchhhh CCCCoooommmmmmmmaaaannnnddddssss
     The repeat search repeats the previous search command, unless there is a
     non-empty selection that is less than a whole line, in which case the
     search is for that.  Thus to find the next occurrence of a word that
     already appears as text, double-click the word, and type <A-f>.

     Regular expression search and replace commands use the regular
     expressions recognized by "ed".  Try "man ed" for more information. _J_o_t
     cannot search for regular expressions containing a newline.

   CCCCttttaaaaggggssss
     _J_o_t has a "Jump to tag" command that searches for a file called "tags" in
     the current directory produced by the program ctags.  If a word is
     selected (usually a procedure name), jump to tag will use that word as
     the tag name; otherwise, it will ask for the name.

   TTTTrrrraaaannnnssssppppoooosssseeee
     If the selection is empty (the cursor is between two characters, the
     transpose command swaps the characters on both sides and advances to the
     right.  This makes it easy to drag a character to the right an arbitrary
     distance.

     If there's a non-empty selection, the entire selection is reversed. There
     is no good reason to do this, but the results can be really entertaining.

   SSSSpppplllliiiitttt WWWWiiiinnnnddddoooowwww
     _J_o_t only knows about a single window, but the split window command fires
     up another version viewing the same file.  The two _j_o_ts are completely
     independent, but one is made view-only for protection.

   CCCCuuuutttt aaaannnndddd PPPPaaaasssstttteeee
     _J_o_t originally ran on non-X platforms, and used a cut and paste strategy
     where the buffer was saved as /tmp/.cutbuffer.  This mechanism remains,
     together with the X-based cut and paste commands.  _J_o_t effectively has
     two cut buffers.

     The non-X cut and paste buffer can be appended to, so it is easy to
     collect a lot of text from a file using <A-z> and paste it all at once.




                                                                       PPPPaaaaggggeeee 11113333






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     To cut and paste text to and from other X processes requires the X cut
     and paste mechanism.  Each text selection automatically becomes the X
     selection, and <middlemouse> pastes it.  It doesn't behave exactly as
     most X processes, however, in that making a selection in another process
     does not unselect the _j_o_t selection.

   UUUUnnnnddddoooo aaaannnndddd RRRReeeeddddoooo
     Each time the undo command is invoked, _j_o_t undoes one more operation.
     For example, if "abcde" is typed followed by 3 undos, first the 'e', then
     the 'd', and finally the 'c' is removed.  Redo steps forward, undoing the
     undos.  After some undos have been typed, a single non-redo command
     clobbers any possibility of continuing with the redo sequence.

   FFFFiiiilllltttteeeerrrrssss
     An arbitrary UNIX command can be applied to the current selection, and
     the results of the filter are placed in the (non-X) cut buffer. For
     example, to sort a bunch of lines, select them (including the final
     newline), invoke the filter command with <C-G>, and type "sort" as the
     filter command.  The sort command executes, and the output replaces the
     contents of the cut buffer, the first few lines of which are displayed.
     Thus, a simple paste replaces the original selected lines.  If you make a
     mistake, just don't do the paste, and try again.  And there's always
     undo.

     The filter command can take the UNIX command from the cutbuffer so it can
     be used in macros.  It can also redirect the output to the invoking shell
     so that compiles, for example, can run independently of the rest of the
     _j_o_t session.

   MMMMaaaarrrrkkkkssss
     A mark is simply a position between a pair of characters in a file. The
     marks stay between the same two characters, if possible, so if the mark
     is near the end of the file, and characters are typed near the beginning,
     the mark effectively moves further from the beginning.  There are 10
     marks available, numbered 0 through 9.  The positions of the marks are
     roughly displayed in the scroll bar by their corresponding numbers.
     Clicking with the right mouse button on the mark in the scroll bar places
     the cursor at the mark.

     The selection is bounded by two text pointers.  If the selection is
     empty, the two text pointers are at the same place.  There are commands
     that take the text pointers and convert them to marks and vice-versa, and
     a command to swap the marks and the text pointers. This is often very
     useful in macros.

   KKKKiiiillllllll ttttoooo EEEEnnnndddd ooooffff LLLLiiiinnnneeee
     If there is any text beyond the cursor in a line, <C-k> kills to the end
     of the line, but does not kill the newline character.  If there is no
     text, <C-k> kills the newline, appending the current line with the next.
     Thus usually two <C-k>s are required to kill each line.





                                                                       PPPPaaaaggggeeee 11114444






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     However, if there is a command multiplier, it is used as the actual
     number of lines (including newlines) to kill.  <A-3><C-k> kills 3 entire
     lines.

     Finally, repeated <C-k> commands append the cut material to the contents
     of the cut buffer -- the first <C-k> replaces the cut buffer with the
     kill contents and each successive <C-k> adds more to the cutbuffer.  <C-
     u> (kill to beginning of line) does not append successive kills to the
     beginning of the cutbuffer as might be expected.

CCCCOOOOMMMMMMMMAAAANNNNDDDD NNNNAAAAMMMMEEEESSSS
     These are the names used by the mapkey command in the .jotrc file.

     APPENDTOBUFFERCMD     append selection to cut buffer
     ASKFILTERCMD          apply UNIX filter to the selection
     ASKREGEXSEARCHCMD     regular expression search
     ASKREVSEARCHCMD       reverse search
     ASKSEARCHCMD          forward search
     ASKSHELLFILTERCMD     apply filter; results to shell
     BACKSPACECMD          backspace
     BACKSPACENUKECMD      backspace; hack tabs to spaces
     BACKTABCMD            backward tab
     BACKWORDCMD           move the cursor back a word
     BEGINFILECMD          jump to the start of the file
     BEGINLINECMD          move cursor to start of line
     BOUNDEDREREPLACECMD   bounded regex replace
     BOUNDEDREPALCECMD     bounded replace
     CALLF1MACROCMD        call macro F1
     CALLF2MACROCMD        call macro F2
     CALLF3MACROCMD        call macro F3
     CALLF4MACROCMD        call macro F4
     CALLF5MACROCMD        call macro F5
     CALLF6MACROCMD        call macro F6
     CALLF7MACROCMD        call macro F7
     CALLF8MACROCMD        call macro F8
     CALLF9MACROCMD        call macro F9
     CALLF10MACROCMD       call macro F10
     CALLF11MACROCMD       call macro F11
     CALLF12MACROCMD       call macro F12
     CENTERLINECMD         center selected lines
     COPYCMD               copy selection to cut buffer
     CRAFTERCURSORCMD      add newline after the cursor
     CURSORDOWNCMD         cursor down a line
     CURSORLEFTCMD         cursor left a character
     CURSORRIGHTCMD        cursor right a character
     CURSORUPCMD           cursor up a line
     CUTBUFFILTERCMD       use the cut buffer as a filter
     CUTCMD                cut selection into cut buffer
     CYCLEFILECMD          cycle to next file
     CYCLESEARCHCMD        cycle files during search
     DEFF1MACROCMD         define macro F1
     DEFF2MACROCMD         define macro F2



                                                                       PPPPaaaaggggeeee 11115555






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     DEFF3MACROCMD         define macro F3
     DEFF4MACROCMD         define macro F4
     DEFF5MACROCMD         define macro F5
     DEFF6MACROCMD         define macro F6
     DEFF7MACROCMD         define macro F7
     DEFF8MACROCMD         define macro F8
     DEFF9MACROCMD         define macro F9
     DEFF10MACROCMD        define macro F10
     DEFF11MACROCMD        define macro F11
     DEFF12MACROCMD        define macro F12
     DELETEMARKCMD         delete mark
     DELETENEXTCHARCMD     delete character after cursor
     DOWNPARAGRAPHCMD      cursor down a paragraph
     ELECTRICCOMMENTCMD    add a C comment
     ENDFILECMD            jump to the end of the file
     ENDLINECMD            cursor to the end of the line
     ESASKSEARCHCMD        extend select search
     ESBACKWORDCMD         extend select back a word
     ESBEGINFILECMD        extend select to top of file
     ESBEGINLINECMD        extend select to start of line
     ESCURSORDOWNCMD       extend select down a line
     ESCURSORLEFTCMD       extend select left a character
     ESCURSORRIGHTCMD      extend select right a character
     ESCURSORUPCMD         extend select up a line
     ESDELETENEXTCHARCMD   delete selection plus character
     ESDOWNPARAGRAPHCMD    extend select to end paragraph
     ESENDFILECMD          extend select to end of file
     ESENDLINECMD          extend select to end of line
     ESFWDWORDCMD          extend select to next word
     ESGOTOLINECMD         extend select to line
     ESSEARCHCMD           extend select search
     ESUPPARAGRAPHCMD      extend select up a paragraph
     FIRSTUPPERCMD         first character to uppercase
     FWDWORDCMD            cursor forward a word
     GETLINERANGE          display range of the selection
     GOTOCOLUMNCMD         go to column
     GOTOLINECMD           go to line
     GOTOMARKCMD           go to mark
     HALFPAGEDOWNCMD       go down a half page
     HALFPAGEUPCMD         go up a half page
     HELPCMD               display help
     INDENTCMD             indent selected lines
     INDENTNEWCMD          insert newline with indentation
     INSERTBRACECMD        insert the '' character
     INSERTFILECMD         insert the contents of a file
     INSERTFILENAMECMD     insert this file name as text
     INSERTRAWNEWLINECMD   insert a newline character
     INSERTTABCMD          insert a tab character
     JUMPTOTAGCMD          jump to tag
     KBDREPLACECMD         replace command
     KILLBACKWORDCMD       kill word before cursor
     KILLTOBGNLINECMD      kill to start of line



                                                                       PPPPaaaaggggeeee 11116666






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     KILLTOEOLCMD          kill to end of line
     KILLWORDCMD           kill the next word
     LITERALESCAPE         use command count as ascii
     MARKSTOTPSCMD         put marks 8, 9 into text pointers
     NEWFILECMD            visit a new file
     OPENCMD               open a file
     OPENLINECMD           open a line after the cursor
     OPENPREVLINECMD       open a line before the cursor
     OUTDENTCMD            outdent selected lines
     PAGEDOWNCMD           move down a screenful
     PAGEUPCMD             move up a screenful
     PARENMATCHCMD         select bracketed text
     PASTEANDREGEXCMD      paste + repeat reg exp search
     PASTECMD              paste contents of cut buffer
     PASTENSEARCHCMD       paste and repeat search
     QUITCMD               quit
     QUITDAMMITCMD         quit no matter what
     REDOCMD               redo command
     REFORMATREGIONCMD     reformat selected region
     REGEXREPLACECMD       regular expression replace
     REGEXSEARCHCMD        regular expression search
     REOPENCMD             reopen a previously visited file
     REPEATCMDCMD          repeat the last typein
     REPLACECMD            replace command
     REVSEARCHCMD          search backwards
     SAVEASCMD             save with new file name
     SAVECMD               save the buffer
     SAVEMACRODEFSCMD      save macro definitions
     SAVEQUITCMD           save the file and quit
     SCROLLDOWNCMD         scroll down
     SCROLLLEFTCMD         scroll left
     SCROLLRIGHTCMD        scroll right
     SCROLLUPCMD           scroll up
     SEARCHCMD             search command
     SELECTALLCMD          select entire buffer
     SELECTLINECMD         select the line
     SELECTPARAGRAPHCMD    select the paragraph
     SETMARKCMD            set a mark at the cursor
     SHOWCUTBUFCMD         show the cutbuffer
     SWAPMARKSTPSCMD       swap marks 8,9 and textpointers
     TOBEGINFILECMD        view start of file
     TOENDFILECMD          view end of file
     TOGGLEAUTOINDENTCMD   toggle auto indent on newline
     TOGGLECASECMD         toggle case-dependent search
     TOGGLEELECCCMD        toggle  electric-C mode
     TOGGLENUMBERSCMD      toggle line number display
     TOGGLEVIEWCMD         toggle of view-only mode
     TOGGLEWORDWRAPCMD     toggle word-wrap mode
     TOLOWERCMD            convert to lower case
     TOTP1CMD              view the first text pointer
     TOTP2CMD              view the last text pointer
     TOUPPERCMD            convert to upper case



                                                                       PPPPaaaaggggeeee 11117777






JJJJOOOOTTTT((((1111GGGG))))                                                                JJJJOOOOTTTT((((1111GGGG))))



     TPSTOMARKSCMD         put text pointers into marks 8,9
     TRANSPOSECMD          transpose characters
     TUTORIALCMD           run the tutorial
     UNDOCMD               undo the last command
     UPPARAGRAPHCMD        move up a paragraph
     WINSPLITCMD           split window
     XCOPYCMD              copy to X cut buffer
     XCUTCMD               cut to X cut buffer
     XPASTECMD             paste from X cut buffer
     ZERO                  disable normal action of key

AAAAUUUUTTTTHHHHOOOORRRR
     _J_o_t was originally called zip, and was written by Tom Davis and Derrick
     Burns of Silicon Graphics.  Some of the conversion from zip to _j_o_t was
     done by Chris Eveland of Silicon Graphics.

FFFFIIIILLLLEEEESSSS
     /usr/sbin/jot                               Executable
     /usr/lib/jot/jotxgizmo                      X agent for X cut and paste
     /usr/lib/jot/browsegizmo                    File selection dialog
     ~/.jotrc                                    _j_o_t options
     ~/.jotmacs                                  _j_o_t macros

BBBBUUUUGGGGSSSS
     Line numbers only work correctly for files with fewer than 100000 lines.

     When you run "jot -M" over a network on a remote file, sometimes _j_o_t just
     dies and goes away with no warning.



























                                                                       PPPPaaaaggggeeee 11118888